/**
 * 文件名:ValidateUtil.java
 * 版本信息:1.0
 * 日期:2015-5-24
 * Copyright 广州点步信息科技
 * 版权所有
 */
package com.dbumama.market.service.utils;

import java.util.Calendar;
import java.util.Collection;
import java.util.regex.Pattern;

/**
 * @author: wjun.java@gmail.com
 * @date:2015-5-24
 */
public class ValidateUtil {
    /**
     * 字符串缺省状态
     */
    private static final boolean DEFAULT_EMPTY_OK = false;

    /**
     * 数字chars
     */
    private static final String DIGITS = "0123456789";

    /**
     * 小写字母chars
     */
    public static final String LETTERS_LOWERCASE = "abcdefghijklmnopqrstuvwxyz";

    /**
     * 小写字母chars + 数字
     */
    public static final String LETTERS_LOWERCASE_DIGITS = LETTERS_LOWERCASE
            + DIGITS;

    /**
     * 大写字母chars
     */
    public static final String LETTERS_UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    /**
     * 大写字母chars + 数字
     */
    public static final String LETTERS_UPPERCASE_DIGITS = LETTERS_UPPERCASE
            + DIGITS;

    /**
     * 全部字母chars
     */
    public static final String LETTERS = LETTERS_LOWERCASE + LETTERS_UPPERCASE;

    /**
     * 全部字母数字
     */
    public static final String LETTERS_DIGITS = LETTERS + DIGITS;

    /**
     * 空白的chars (包括空格,\t,\n,\r)
     */
    private static final String WHITE_SPACE = " \t\n\r";

    /**
     * 小数点
     */
    private static final String DECIMAL_POING_DELIMITER = ".";

    /**
     * 电话号码里允许的不是数字的chars ,两边括号,横线,空格
     */
    private static final String PHONE_NUMBER_DELIMITERS = "()- ";

    /**
     * 全球电话号码允许"+"号的chars
     */
    private static final String VALID_PHONE_CHARS_WORLD = "+" + DIGITS
            + PHONE_NUMBER_DELIMITERS;

    /**
     * 手机号码允许"+"号和数字,但只允许第一个字符是+号,验证是检查是否第一个是,如果是去除再验证
     */
    private static final String VALID_MSISDN_CHARS = DIGITS;

    /**
     * 手机号码允许的最大长度
     */
    private static final int VALID_MSISDN_MAXLEN = 21;

    /**
     * 手机号码允许的最小长度
     */
    private static final int VALID_MSISDN_MINLEN = 11;

    /**
     * 定义12月份对应的天数
     */
    private static final int[] DAYS_IN_MONTH = {31, 29, 31, 30, 31, 30, 31,
            31, 30, 31, 30, 31};

    /**
     * 检查两个对象是否相等
     */
    public static boolean isEqual(Object obj, Object obj2) {
        return (obj == null) ? (obj2 == null) : obj.equals(obj2);
    }

    /**
     * 检查字符串是否为空
     */
    public static boolean isEmpty(Object obj) {
        if (obj == null)
            return true;

        if (obj instanceof String)
            return isEmpty((String) obj);

        return false;
    }

    /**
     * 检查字符串是否为空
     */
    public static boolean isEmpty(String s) {
        return ((s == null) || (s.trim().length() == 0));
    }

    /**
     * 检查集合是否为空
     */
    public static boolean isEmpty(Collection<?> c) {
        return ((c == null) || (c.size() == 0));
    }

    /**
     * 检查字符串是否不为空
     */
    public static boolean isNotEmpty(String s) {
        return ((s != null) && (s.trim().length() > 0));
    }

    /**
     * 检查集合是否不为空
     */
    public static boolean isNotEmpty(Collection<?> c) {
        return ((c != null) && (c.size() > 0));
    }

    /**
     * 如果s中存在c,则返回true,否则返回false
     */
    public static boolean isCharInString(char c, String s) {
        return (s.indexOf(c) != -1);
    }

    /**
     * 检查字符是否是大写字母,(注:A-Z之间)
     */
    public static boolean isLetterUppercase(char c) {
        return LETTERS_UPPERCASE.indexOf(c) != -1;
    }

    /**
     * 检查字符是否是大写字母加数字,(注:A-Z,0-9之间)
     */
    public static boolean isLetterUppercaseDigits(char c) {
        return LETTERS_UPPERCASE_DIGITS.indexOf(c) != -1;
    }

    /**
     * 检查字符是否是小写字母,(注:a-z之间)
     */
    public static boolean isLetterLowercase(char c) {
        return LETTERS_LOWERCASE.indexOf(c) != -1;
    }

    /**
     * 检查字符是否是小写字母加数字,(注:a-z,0-9之间)
     */
    public static boolean isLetterLowercaseDigits(char c) {
        return LETTERS_LOWERCASE_DIGITS.indexOf(c) != -1;
    }

    /**
     * 检查字符是否是字母,(注:a-z,A-Z之间)
     */
    public static boolean isLetter(char c) {
        return LETTERS.indexOf(c) != -1;
    }

    /**
     * 检查字符是否是数字
     */
    public static boolean isDigit(char c) {
        return DIGITS.indexOf(c) != -1;
    }

    /**
     * 检查字符是否是数字或字母
     */
    public static boolean isLetterOrDigit(char c) {
        return LETTERS_DIGITS.indexOf(c) != -1;
    }

    /**
     * 1\如果字符串为空或全是whitespace中的值则返回true,存在一个不是则返回false 2\见whitespace定义
     * whitespace = " \t\n\r";(空格,\t,\n,\r)
     */
    public static boolean isWhitespace(String s) {
        if (isEmpty(s))
            return true;

        // 逐个字符检查,如果发现一个不是whitespace,则返回false
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (WHITE_SPACE.indexOf(c) == -1)
                return false;
        }

        return true;
    }

    /**
     * 检查是否是指定的长度，注:当s=null || s="",min=0时为true
     */
    public static boolean isLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        return (s.length() >= min && s.length() <= max);
    }

    /**
     * 检查是否GBK编码长度，数据库一般是一个汉字两个字节
     */
    public static boolean isByteLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        int len = 0;
        try {
            len = s.getBytes("GBK").length;
        } catch (Exception e) {
            len = s.getBytes().length;
        }
        return (len >= min && len <= max);
    }

    /**
     * 检查是否指定编码长度，UTF-8是一个汉字3个字节，GBK是两个
     */
    public static boolean isByteLen(String s, int min, int max, String encoding) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        int len = 0;
        try {
            len = s.getBytes(encoding).length;
        } catch (Exception e) {
            len = s.getBytes().length;
        }
        return (len >= min && len <= max);
    }

    /**
     * 检查是否是整型
     */
    public static boolean isInteger(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        // 逐个检查,如果出现一个字符不是数字则返回false
        for (int i = 0; i < s.length(); i++) {
            if (!isDigit(s.charAt(i)))
                return false;
        }

        return true;
    }

    /**
     * 检查是否是带符号的整型(允许第一个字符为"+,-",不接受浮点".",指数"E"等
     */
    public static boolean isSignedInteger(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            Integer.parseInt(s);

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查是否是带符号的长整型(允许第一个字符为"+,-",不接受浮点".",指数"E"等
     */
    public static boolean isSignedLong(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            Long.parseLong(s);

            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查是否是一个正整数
     */
    public static boolean isPositiveInteger(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            long temp = Long.parseLong(s);

            if (temp > 0)
                return true;
            return false;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查是否是一个非负整数
     */
    public static boolean isNonnegativeInteger(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            int temp = Integer.parseInt(s);

            if (temp >= 0)
                return true;
            return false;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查是否是一个负整数
     */
    public static boolean isNegativeInteger(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            int temp = Integer.parseInt(s);

            if (temp < 0)
                return true;
            return false;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查是否是一个非正整数
     */
    public static boolean isNonpositiveInteger(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            int temp = Integer.parseInt(s);

            if (temp <= 0)
                return true;
            return false;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查字符串是否是整型,且在a,b之间,>=a,<=b
     */
    public static boolean isIntegerInRange(String s, int a, int b) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        if (!isSignedInteger(s))
            return false;

        int num = Integer.parseInt(s);

        return ((num >= a) && (num <= b));
    }

    /**
     * 检查字符串是否是正整型,且在a,b之间,>=a,<=b
     */
    public static boolean isIntegerInRangeLen(String s, int a, int b) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        if (!isInteger(s))
            return false;

        return ((s.length() >= a) && (s.length() <= b));
    }

    /**
     * 是否是Unicode码
     */
    public static final boolean isUnicode(String str) {
        if (isEmpty(str))
            return false;

        int len = str.length();
        for (int i = 0; i < len; i++) {
            if ((int) str.charAt(i) > 128)
                return true;
        }
        if (str.length() == 1) {
            if (((int) str.charAt(0)) > 128)
                return true;
        }
        return false;

    }

    /**
     * 检查是否是一个无符号的浮点型,不支持指点E
     */
    public static boolean isFloat(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        if (s.startsWith(DECIMAL_POING_DELIMITER))
            return false;

        // 只允许一个点.
        boolean seenDecimalPoint = false;

        // 逐个字符检查
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (isDigit(c))
                continue;

            if (c == DECIMAL_POING_DELIMITER.charAt(0)) {
                if (!seenDecimalPoint) {
                    seenDecimalPoint = true;
                    continue;
                }
            }

            return false;
        }

        return true;
    }

    /**
     * 检查是否是一个允许符号的浮点型,允许符号"+","-"
     */
    public static boolean isSignedFloat(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            float temp = Float.parseFloat(s);

            if (temp <= 0)
                return true;

            return false;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查是否是一个允许符号的双精度浮点型,允许符号"+","-"
     */
    public static boolean isSignedDouble(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        try {
            Double.parseDouble(s);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 检查字符串是否都是由字母组成
     */
    public static boolean isAlphabetic(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isLetter(c))
                return false;
        }

        return true;
    }

    /**
     * 检查字符串是否都是由小写字母组成
     */
    public static boolean isAlphabeticLowercase(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isLetterLowercase(c))
                return false;
        }

        return true;
    }

    /**
     * 检查字符串是否都是由大写字母组成
     */
    public static boolean isAlphabeticUppercase(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isLetterUppercase(c))
                return false;
        }

        return true;
    }

    /**
     * 检查字符串是否都是由字母组成且长度在min,max范围内
     */
    public static boolean isAlphabeticLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        if (!isAlphabetic(s))
            return false;

        if (s.length() < min || s.length() > max)
            return false;

        return true;
    }

    /**
     * 检查字符串是否都是由小写字母组成且长度在min,max范围内
     */
    public static boolean isAlphabeticLowercaseLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        if (!isAlphabeticLowercase(s))
            return false;

        if (s.length() < min || s.length() > max)
            return false;

        return true;
    }

    /**
     * 检查字符串是否都是由大字母组成且长度在min,max范围内
     */
    public static boolean isAlphabeticUpperLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        if (!isAlphabeticUppercase(s))
            return false;

        if (s.length() < min || s.length() > max)
            return false;

        return true;
    }

    /**
     * 检查字符串是否都是由字母或数字组成
     */
    public static boolean isAlphanumeric(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isLetterOrDigit(c))
                return false;
        }

        return true;
    }

    /**
     * 检查字符串是否都是由字母或数字组成且长度在min,max范围内
     */
    public static boolean isAlphanumericLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        if (!isAlphanumeric(s))
            return false;

        if (s.length() < min || s.length() > max)
            return false;

        return true;
    }

    /**
     * 检查字符串是否都是由大写字母或数字组成
     */
    public static boolean isAlphaUpperNumeric(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isLetterUppercaseDigits(c))
                return false;
        }

        return true;
    }

    /**
     * 检查字符串是否都是由大写字母或数字组成
     */
    public static boolean isAlphaLowerNumeric(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isLetterLowercaseDigits(c))
                return false;
        }

        return true;
    }

    /**
     * 检查字符串是否都是由大写字母或数字组成
     */
    public static boolean isAlphaUpperNumericLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        if (!isAlphaUpperNumeric(s))
            return false;

        if (s.length() < min || s.length() > max)
            return false;

        return true;
    }

    /**
     * 检查字符串是否都是由小写字母或数字组成
     */
    public static boolean isAlphaLowerNumericLen(String s, int min, int max) {
        if (isEmpty(s))
            return min == 0 ? true : false;

        if (!isAlphaLowerNumeric(s))
            return false;

        if (s.length() < min || s.length() > max)
            return false;

        return true;
    }

    /**
     * 检查字符串是否正确的邮政编码
     */
    public static boolean isZipCode(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        if (s.length() != 6 || !isInteger(s))
            return false;

        return true;
    }

    public static boolean isMoneyTwoRadix(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        // 去除负号
        if (s.startsWith("-"))
            s = s.substring(1);

        int ind = s.indexOf(".");
        if (ind == -1)
            return isInteger(s);// 如果没有点号，则判断是否是整数

        if (ind == 0)
            return false;

        String integer = s.substring(0, ind);
        String radix = s.substring(ind + 1);
        if (!isInteger(integer) || !isIntegerInRangeLen(radix, 2, 2))
            return false;// 如果整数部分不是整数，小数部分不是整数，或小数部分不是两位

        return true;
    }

    /**
     * 检查字符串是否正确的邮件地址(注:要求存在@字符,且不是出现在第一个,最后一个位置,现在不检查是否存在".")
     */
    public static boolean isEmail(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        if (isWhitespace(s))
            return false;

        int indexLeft = s.indexOf('@');
        int indexRight = s.lastIndexOf('@');

        // 如果不存在@,或不止一个,或第一个,或最后一个
        if (indexLeft < 1 || indexLeft != indexRight || indexLeft == s.length())
            return false;

        return true;
    }

    /**
     * 检查是否是正确的年
     */
    public static boolean isYear(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        if (!isNonnegativeInteger(s))
            return false;

        return ((s.length() == 2) || (s.length() == 4));
    }

    /**
     * 判断是否是周末 yyyy-MM-dd
     */
    public static boolean isWeekend(String date) {
        Calendar calendar = DateTimeUtil.toCalendar(date + " 00:00:01");
        return calendar.get(Calendar.DAY_OF_WEEK) == 1;
    }

    /**
     * 判断是否季度末 yyyy-MM-dd
     */
    public static boolean isMonthQuarter(String date) {
        if (!isDate(date))
            return false;

        String year = date.substring(0, 4);
        String month = date.substring(5, 7);
        String day = date.substring(8);

        if (!isMonthLastDay(year, month, day))
            return false;

        if (month.equals("03") || month.equals("06") || month.equals("09")
                || month.equals("12"))
            return true;

        return false;
    }

    /**
     * 判断是否年末 yyyy-MM-dd
     */
    public static boolean isYearLastDay(String date) {
        if (!isDate(date))
            return false;

        String year = date.substring(0, 4);
        String month = date.substring(5, 7);
        String day = date.substring(8);

        if (!isMonthLastDay(year, month, day))
            return false;

        if (month.equals("12"))
            return true;

        return false;
    }

    /**
     * 检查是否是正确的月
     */
    public static boolean isMonth(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        return isIntegerInRange(s, 1, 12);
    }

    /**
     * 检查是否是正确的日
     */
    public static boolean isDay(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        return isIntegerInRange(s, 1, 31);
    }

    /**
     * 检查是否闰年
     */
    public static boolean isLeapYear(int year) {
        return (year % 4 == 0) && ((!(year % 100 == 0)) || (year % 400 == 0));
    }

    /**
     * 检查是否是月末 yyyy-MM-dd HH:mm:ss
     */
    public static boolean isMonthLastDay(String date) {
        if (!isDate(date))
            return false;

        String year = date.substring(0, 4);
        String month = date.substring(5, 7);
        String day = date.substring(8);
        return isMonthLastDay(year, month, day);
    }

    /**
     * 检查是否是月末
     */
    public static boolean isMonthLastDay(String year, String month, String day) {
        if (!isDate(year, month, day))
            return false;

        int yearInt = Integer.parseInt(year);
        int monthInt = Integer.parseInt(month);
        int dayInt = Integer.parseInt(day);
        return isMonthLastDay(yearInt, monthInt, dayInt);
    }

    /**
     * 检查是否是月末
     */
    public static boolean isMonthLastDay(int year, int month, int day) {
        if (year < 1000 || year > 9999 || month > 12 || month < 1 || day > 31
                || day < 1)
            return false;

        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                return day == 31;
            case 4:
            case 6:
            case 9:
            case 11:
                return day == 30;
            default:// 2月
                boolean isLeapYear = ValidateUtil.isLeapYear(year);
                return isLeapYear ? day == 29 : day == 28;
        }
    }

    /**
     * 检查是否是正确的时
     */
    public static boolean isHour(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        return isIntegerInRange(s, 0, 23);
    }

    /**
     * 检查是否是正确的分
     */
    public static boolean isMinute(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;
        return isIntegerInRange(s, 0, 59);
    }

    /**
     * 检查是否是正确的秒
     */
    public static boolean isSecond(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;
        return isIntegerInRange(s, 0, 59);
    }

    /**
     * 检查是否是正确的日期
     */
    public static boolean isDate(String year, String month, String day) {
        if (!(isYear(year) && isMonth(month) && isDay(day)))
            return false;

        int intYear = Integer.parseInt(year);
        int intMonth = Integer.parseInt(month);
        int intDay = Integer.parseInt(day);

        if (intDay > DAYS_IN_MONTH[intMonth - 1])
            return false;

        if ((intMonth == 2) && (intDay > (isLeapYear(intYear) ? 29 : 28)))
            return false;

        return true;
    }

    /**
     * 检查是否是正确的日期
     */
    public static boolean isDate(String date) {
        if (isEmpty(date))
            return DEFAULT_EMPTY_OK;

        if (date.length() != 10)
            return DEFAULT_EMPTY_OK;

        int dateSlash1 = date.indexOf("-");
        int dateSlash2 = date.lastIndexOf("-");

        if (dateSlash1 <= 0 || dateSlash1 == dateSlash2)
            return false;

        String year = date.substring(0, dateSlash1);
        String month = date.substring(dateSlash1 + 1, dateSlash2);
        String day = date.substring(dateSlash2 + 1);

        return isDate(year, month, day);
    }

    /**
     * 判断是不是指定的时间格式
     */
    public static boolean isDateTime(String datetime) {
        if (isEmpty(datetime))
            return false;

        datetime = datetime.trim();
        String[] strs = datetime.split(" ");
        if (strs.length != 2)
            return false;

        return isDate(strs[0]) && isTime(strs[1]);
    }

    /**
     * 判断是不是指定的时间格式, spe为日期分隔符
     */
    public static boolean isDateTime(String datetime, String spe) {
        if (isEmpty(datetime))
            return false;

        datetime = datetime.trim();
        String[] strs = datetime.split(" ");
        if (strs.length != 2)
            return false;

        return isDate(strs[0].replaceAll(spe, "-")) && isTime(strs[1]);
    }

    /**
     * 检查是否是西方正确的日期
     */
    public static boolean isEnglishDate(String date) {
        if (isEmpty(date))
            return DEFAULT_EMPTY_OK;

        int dateSlash1 = date.indexOf("/");
        int dateSlash2 = date.lastIndexOf("/");

        if (dateSlash1 <= 0 || dateSlash1 == dateSlash2)
            return false;

        String month = date.substring(0, dateSlash1);
        String day = date.substring(dateSlash1 + 1, dateSlash2);
        String year = date.substring(dateSlash2 + 1);

        return isDate(year, month, day);
    }

    /**
     * 检查是否是日期比今天大
     */
    public static boolean isDateAfterToday(String date) {
        if (isDate(date))
            return DEFAULT_EMPTY_OK;

        java.util.Date passed = DateTimeUtil.toDate(date, "00:00:00");
        java.util.Date now = DateTimeUtil.nowDate();

        return passed.after(now);
    }

    /**
     * 检查是否是正确的时间
     */
    public static boolean isTime(String hour, String minute, String second) {
        if (isHour(hour) && isMinute(minute) && isSecond(second))
            return true;

        return false;
    }

    /**
     * 检查是否是正确的时间
     */
    public static boolean isTime(String time) {
        if (isEmpty(time))
            return DEFAULT_EMPTY_OK;

        int timeColon1 = time.indexOf(":");
        int timeColon2 = time.lastIndexOf(":");

        if (timeColon1 <= 0 || timeColon1 == timeColon2)
            return false;

        String hour = time.substring(0, timeColon1);
        String minute = time.substring(timeColon1 + 1, timeColon2);
        String second = time.substring(timeColon2 + 1);

        return isTime(hour, minute, second);
    }

    /**
     * 检查是否是正确的电话号码
     */
    public static boolean isPhone(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        // 逐个字符检查,如果发现一个不是whitespace,则返回false
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isCharInString(c, VALID_PHONE_CHARS_WORLD))
                return false;
        }

        return true;
    }

    /**
     * 检查是否是正确的手机号码
     */
    public static boolean isMsisdn(String s) {
        if (isEmpty(s))
            return DEFAULT_EMPTY_OK;

        // 如果第一个是+号,则去除
        if (s.charAt(0) == '+')
            s = s.substring(1);

        if (s.length() > VALID_MSISDN_MAXLEN
                || s.length() < VALID_MSISDN_MINLEN)
            return false;

        // 逐个字符检查,如果发现一个不是VALID_MSISDN_CHARS,则返回false
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!isCharInString(c, VALID_MSISDN_CHARS))
                return false;
        }

        return true;
    }

    /**
     * 判断号码是否符合配置文件所设条件
     *
     * @param phone 号码字符串
     * @return boolean =true 是手机号码,=false 非手机号码
     * @oaram prefixs 固定前三个的前缀,如135,136,159等,多个用逗号隔开
     */
    public static boolean isMsisdn11(String phone, String prefixs) {
        if (!isIntegerInRangeLen(phone, 11, 11))
            return false;

        String[] prefixArr = prefixs.split(",");
        for (int i = 0; i < prefixArr.length; i++) {
            if (phone.startsWith(prefixArr[i]))
                return true;
        }

        return false;
    }

    /**
     * 判断号码是否符合配置文件所设条件
     *
     * @param phone   号码字符串
     * @param prefixs 前缀数组，如135,137,+86,0086,17951135等,多个用逗号隔开
     * @return boolean =true 是手机号码,=false 非手机号码
     */
    public static boolean isMsisdn21(String phone, String prefixs) {
        if (!isMsisdn(phone))
            return false;

        String[] prefixArr = prefixs.split(",");
        for (int i = 0; i < prefixArr.length; i++) {
            if (phone.length() != prefixArr[i].length() + 8)
                continue;

            if (phone.startsWith(prefixArr[i]))
                return true;
        }

        return false;
    }

    /**
     * 检查是否是IP地址,ip为空返回false;
     */
    public static boolean isIP(String ip) {
        return isIP(ip, false);
    }

    /**
     * 检查是否是IP地址
     */
    public static boolean isIP(String ip, boolean allowEmpty) {
        if (isEmpty(ip))
            return allowEmpty;

        try {
            int ind1 = ip.indexOf('.');
            if (ind1 == -1)
                return false;

            String str1 = ip.substring(0, ind1);
            if (!ValidateUtil.isIntegerInRange(str1, 0, 255))
                return false;

            int ind2 = ip.indexOf('.', ind1 + 1);
            if (ind2 == -1)
                return false;

            String str2 = ip.substring(ind1 + 1, ind2);
            if (!ValidateUtil.isIntegerInRange(str2, 0, 255))
                return false;

            int ind3 = ip.indexOf('.', ind2 + 1);
            if (ind3 == -1)
                return false;

            String str3 = ip.substring(ind2 + 1, ind3);
            if (!ValidateUtil.isIntegerInRange(str3, 0, 255))
                return false;

            String str4 = ip.substring(ind3 + 1);
            if (!ValidateUtil.isIntegerInRange(str4, 0, 255))
                return false;
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 检查是否是macAddress,macAddress为空返回false;
     */
    public static boolean isMacAddress(String macAddress) {
        return isMacAddress(macAddress, false);
    }

    /**
     * 检查是否是IP地址
     */
    public static boolean isMacAddress(String macAddress, boolean allowEmpty) {
        if (isEmpty(macAddress))
            return allowEmpty;

        return isRegExp(
                macAddress,
                "^[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}$");
    }

    /**
     * 检查是否邮编
     */
    public static boolean isPostalCode(String s) {
        if (!isInteger(s) || s.trim().length() != 6)
            return false;

        return true;
    }

    /**
     * 检查是否在指定的字符串内
     */
    public static boolean isScope(String s, String scope) {
        if (ValidateUtil.isEmpty(s))
            return ValidateUtil.DEFAULT_EMPTY_OK;

        // 逐个字符检查,如果发现一个不是specifyStr,则返回false
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (!ValidateUtil.isCharInString(c, scope))
                return false;
        }

        return true;
    }

    /**
     * 检查value是否符合指定的pattern
     */
    public static boolean isRegExp(String value, String regExp) {
        if (regExp.startsWith("/"))
            regExp = regExp.substring(1);
        if (regExp.endsWith("/"))
            regExp = regExp.substring(0, regExp.length() - 1);
        return Pattern.matches(regExp, value);
    }

    /**
     * 检查src是否包含字符串数组任何一个
     */
    public static boolean isStrContainStrArr(String src, String[] strs) {
        for (String str : strs) {
            if (src.contains(str.trim()))
                return true;
        }

        return false;
    }

    /**
     * 检查src是否包含字符串数组任何一个
     */
    public static boolean isStrContainStrArr(String src, String strArr,
                                             String delm) {
        return isStrContainStrArr(src, strArr.split(delm));
    }
}
